/*
 * Event loop - empty template (basic structure, but no OS specific operations)
 * Copyright (c) 2002-2005, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"

#include "common.h"
#include "eloop.h"


struct eloop_sock {
    int sock;
    void *eloop_data;
    void *user_data;
    void (*handler)(int sock, void *eloop_ctx, void *sock_ctx);
};

struct eloop_timeout {
    struct os_time time;
    void *eloop_data;
    void *user_data;
    void (*handler)(void *eloop_ctx, void *sock_ctx);
    struct eloop_timeout *next;
};

struct eloop_signal {
    int sig;
    void *user_data;
    void (*handler)(int sig, void *eloop_ctx, void *signal_ctx);
    int signaled;
};

struct eloop_data {
    int max_sock, reader_count;
    struct eloop_sock *readers;

    struct eloop_timeout *timeout;

    int signal_count;
    struct eloop_signal *signals;
    int signaled;
    int pending_terminate;

    int terminate;
    int reader_table_changed;
};

static struct eloop_data eloop;


int eloop_init(void)
{
    memset(&eloop, 0, sizeof(eloop));
    return 0;
}


int eloop_register_read_sock(int sock,
        void (*handler)(int sock, void *eloop_ctx,
            void *sock_ctx),
        void *eloop_data, void *user_data)
{
    struct eloop_sock *tmp;

    tmp = (struct eloop_sock *)
        realloc(eloop.readers,
                (eloop.reader_count + 1) * sizeof(struct eloop_sock));
    if (tmp == NULL)
        return -1;

    tmp[eloop.reader_count].sock = sock;
    tmp[eloop.reader_count].eloop_data = eloop_data;
    tmp[eloop.reader_count].user_data = user_data;
    tmp[eloop.reader_count].handler = handler;
    eloop.reader_count++;
    eloop.readers = tmp;
    if (sock > eloop.max_sock)
        eloop.max_sock = sock;
    eloop.reader_table_changed = 1;

    return 0;
}


void eloop_unregister_read_sock(int sock)
{
    int i;

    if (eloop.readers == NULL || eloop.reader_count == 0)
        return;

    for (i = 0; i < eloop.reader_count; i++) {
        if (eloop.readers[i].sock == sock)
            break;
    }
    if (i == eloop.reader_count)
        return;
    if (i != eloop.reader_count - 1) {
        memmove(&eloop.readers[i], &eloop.readers[i + 1],
                (eloop.reader_count - i - 1) *
                sizeof(struct eloop_sock));
    }
    eloop.reader_count--;
    eloop.reader_table_changed = 1;
}


int eloop_register_timeout(unsigned int secs, unsigned int usecs,
        void (*handler)(void *eloop_ctx, void *timeout_ctx),
        void *eloop_data, void *user_data)
{
    struct eloop_timeout *timeout, *tmp, *prev;

    timeout = (struct eloop_timeout *) malloc(sizeof(*timeout));
    if (timeout == NULL)
        return -1;
    os_get_time(&timeout->time);
    timeout->time.sec += secs;
    timeout->time.usec += usecs;
    while (timeout->time.usec >= 1000000) {
        timeout->time.sec++;
        timeout->time.usec -= 1000000;
    }
    timeout->eloop_data = eloop_data;
    timeout->user_data = user_data;
    timeout->handler = handler;
    timeout->next = NULL;

    if (eloop.timeout == NULL) {
        eloop.timeout = timeout;
        return 0;
    }

    prev = NULL;
    tmp = eloop.timeout;
    while (tmp != NULL) {
        if (os_time_before(&timeout->time, &tmp->time))
            break;
        prev = tmp;
        tmp = tmp->next;
    }

    if (prev == NULL) {
        timeout->next = eloop.timeout;
        eloop.timeout = timeout;
    } else {
        timeout->next = prev->next;
        prev->next = timeout;
    }

    return 0;
}


int eloop_cancel_timeout(void (*handler)(void *eloop_ctx, void *sock_ctx),
        void *eloop_data, void *user_data)
{
    struct eloop_timeout *timeout, *prev, *next;
    int removed = 0;

    prev = NULL;
    timeout = eloop.timeout;
    while (timeout != NULL) {
        next = timeout->next;

        if (timeout->handler == handler &&
                (timeout->eloop_data == eloop_data ||
                 eloop_data == ELOOP_ALL_CTX) &&
                (timeout->user_data == user_data ||
                 user_data == ELOOP_ALL_CTX)) {
            if (prev == NULL)
                eloop.timeout = next;
            else
                prev->next = next;
            free(timeout);
            removed++;
        } else
            prev = timeout;

        timeout = next;
    }

    return removed;
}


int eloop_is_timeout_registered(void (*handler)(void *eloop_ctx,
            void *timeout_ctx),
        void *eloop_data, void *user_data)
{
    struct eloop_timeout *tmp;

    tmp = eloop.timeout;
    while (tmp != NULL) {
        if (tmp->handler == handler &&
                tmp->eloop_data == eloop_data &&
                tmp->user_data == user_data)
            return 1;

        tmp = tmp->next;
    }

    return 0;
}


/* TODO: replace with suitable signal handler */
#if 0
static void eloop_handle_signal(int sig)
{
    int i;

    eloop.signaled++;
    for (i = 0; i < eloop.signal_count; i++) {
        if (eloop.signals[i].sig == sig) {
            eloop.signals[i].signaled++;
            break;
        }
    }
}
#endif


static void eloop_process_pending_signals(void)
{
    int i;

    if (eloop.signaled == 0)
        return;
    eloop.signaled = 0;

    if (eloop.pending_terminate) {
        eloop.pending_terminate = 0;
    }

    for (i = 0; i < eloop.signal_count; i++) {
        if (eloop.signals[i].signaled) {
            eloop.signals[i].signaled = 0;
            eloop.signals[i].handler(eloop.signals[i].sig,
                    eloop.user_data,
                    eloop.signals[i].user_data);
        }
    }
}


int eloop_register_signal(int sig,
        void (*handler)(int sig, void *eloop_ctx,
            void *signal_ctx),
        void *user_data)
{
    struct eloop_signal *tmp;

    tmp = (struct eloop_signal *)
        realloc(eloop.signals,
                (eloop.signal_count + 1) *
                sizeof(struct eloop_signal));
    if (tmp == NULL)
        return -1;

    tmp[eloop.signal_count].sig = sig;
    tmp[eloop.signal_count].user_data = user_data;
    tmp[eloop.signal_count].handler = handler;
    tmp[eloop.signal_count].signaled = 0;
    eloop.signal_count++;
    eloop.signals = tmp;

    /* TODO: register signal handler */

    return 0;
}


int eloop_register_signal_terminate(void (*handler)(int sig, void *eloop_ctx,
            void *signal_ctx),
        void *user_data)
{
#if 0
    /* TODO: for example */
    int ret = eloop_register_signal(SIGINT, handler, user_data);
    if (ret == 0)
        ret = eloop_register_signal(SIGTERM, handler, user_data);
    return ret;
#endif
    return 0;
}


int eloop_register_signal_reconfig(void (*handler)(int sig, void *eloop_ctx,
            void *signal_ctx),
        void *user_data)
{
#if 0
    /* TODO: for example */
    return eloop_register_signal(SIGHUP, handler, user_data);
#endif
    return 0;
}


void eloop_run(void)
{
    int i;
    struct os_time tv, now;

    while (!eloop.terminate &&
            (eloop.timeout || eloop.reader_count > 0)) {
        if (eloop.timeout) {
            os_get_time(&now);
            if (os_time_before(&now, &eloop.timeout->time))
                os_time_sub(&eloop.timeout->time, &now, &tv);
            else
                tv.sec = tv.usec = 0;
        }

        /*
         * TODO: wait for any event (read socket ready, timeout (tv),
         * signal
         */
        os_sleep(1, 0); /* just a dummy wait for testing */

        eloop_process_pending_signals();

        /* check if some registered timeouts have occurred */
        if (eloop.timeout) {
            struct eloop_timeout *tmp;

            os_get_time(&now);
            if (!os_time_before(&now, &eloop.timeout->time)) {
                tmp = eloop.timeout;
                eloop.timeout = eloop.timeout->next;
                tmp->handler(tmp->eloop_data,
                        tmp->user_data);
                free(tmp);
            }

        }

        eloop.reader_table_changed = 0;
        for (i = 0; i < eloop.reader_count; i++) {
            /*
             * TODO: call each handler that has pending data to
             * read
             */
            if (0 /* TODO: eloop.readers[i].sock ready */) {
                eloop.readers[i].handler(
                        eloop.readers[i].sock,
                        eloop.readers[i].eloop_data,
                        eloop.readers[i].user_data);
                if (eloop.reader_table_changed)
                    break;
            }
        }
    }
}


void eloop_terminate(void)
{
    eloop.terminate = 1;
}


void eloop_destroy(void)
{
    struct eloop_timeout *timeout, *prev;

    timeout = eloop.timeout;
    while (timeout != NULL) {
        prev = timeout;
        timeout = timeout->next;
        free(prev);
    }
    free(eloop.readers);
    free(eloop.signals);
}


int eloop_terminated(void)
{
    return eloop.terminate;
}


void eloop_wait_for_read_sock(int sock)
{
    /*
     * TODO: wait for the file descriptor to have something available for
     * reading
     */
}
